import { http } from "@/utils/http";

/**
 * 文章标签优化 API 接口
 *
 * 根据 ARTICLE-TAG-API.md 实现
 * 优化功能：数据结构优化、关联表设计、性能优化、功能增强
 */

// ==================== 类型定义 ====================

/** API响应基础类型 */
export interface ApiResponse<T = any> {
  code: number;
  message: string;
  data: T;
  timestamp?: number;
}

/** 分页响应类型 */
export interface PageResult<T> {
  records: T[];
  total: number;
  current: number;
  size: number;
}

/** 标签详细信息 */
export interface TagInfo {
  /** 标签ID */
  id: number;
  /** 标签名称 */
  name: string;
  /** 标签颜色 */
  color: string;
  /** 标签描述 */
  description?: string;
  /** 标签图标 */
  icon?: string;
  /** 排序字段 */
  sortOrder: number;
  /** 使用次数 */
  useCount: number;
  /** 状态 */
  status: number;
  /** 状态文本 */
  statusText: string;
  /** 使用频率等级 */
  usageLevel: number;
  /** 使用频率等级文本 */
  usageLevelText: string;
  /** 创建者 */
  createBy?: string;
  /** 创建时间 */
  createTime: string;
  /** 更新者 */
  updateBy?: string;
  /** 更新时间 */
  updateTime: string;
  /** 关联文章数量 */
  articleCount: number;
}

/** 标签列表查询参数 */
export interface TagListQuery {
  /** 当前页码 */
  current: number;
  /** 每页大小 */
  size: number;
  /** 标签名称（模糊查询） */
  name?: string;
  /** 标签颜色 */
  color?: string;
  /** 状态 */
  status?: number;
  /** 最小使用次数 */
  minUseCount?: number;
  /** 最大使用次数 */
  maxUseCount?: number;
  /** 关键词（名称和描述模糊查询） */
  keyword?: string;
  /** 只查询启用的标签 */
  onlyEnabled?: boolean;
  /** 只查询已使用的标签 */
  onlyUsed?: boolean;
  /** 排序字段 */
  sortField?: string;
  /** 排序方向 */
  sortOrder?: "asc" | "desc";
}

/** 创建标签请求 */
export interface CreateTagRequest {
  /** 标签名称 */
  name: string;
  /** 标签颜色 */
  color: string;
  /** 标签描述 */
  description?: string;
  /** 标签图标 */
  icon?: string;
  /** 排序字段 */
  sortOrder?: number;
  /** 状态 */
  status: number;
}

/** 更新标签请求 */
export interface UpdateTagRequest extends CreateTagRequest {
  /** 标签ID */
  id: number;
}

/** 批量操作参数 */
export interface BatchOperationParams {
  /** 标签ID列表 */
  tagIds: number[];
  /** 操作类型 */
  operation: "enable" | "disable" | "delete" | "resetUseCount" | "updateColor";
  /** 操作参数（可选，如更新颜色时的新颜色值） */
  operationParam?: string;
}

/** 标签统计信息 */
export interface TagStatistics {
  /** 总数量 */
  totalCount: number;
  /** 启用数量 */
  enabledCount: number;
  /** 禁用数量 */
  disabledCount: number;
  /** 已使用数量 */
  usedCount: number;
  /** 未使用数量 */
  unusedCount: number;
  /** 平均使用次数 */
  avgUseCount: number;
  /** 最大使用次数 */
  maxUseCount: number;
  /** 最小使用次数 */
  minUseCount: number;
}

/** 简化的标签信息（用于选择器等） */
export interface SimpleTagInfo {
  /** 标签ID */
  id: number;
  /** 标签名称 */
  name: string;
  /** 标签颜色 */
  color: string;
  /** 使用次数 */
  useCount?: number;
  /** 状态 */
  status?: number;
}

/** 文章标签信息（用于文章详情中的标签显示） */
export interface ArticleTagInfo {
  /** 标签ID */
  id: number;
  /** 标签名称 */
  name: string;
  /** 标签颜色 */
  color: string;
  /** 标签描述 */
  description?: string;
  /** 标签图标 */
  icon?: string;
  /** 使用次数 */
  useCount: number;
}

// ==================== 标签管理接口 ====================

/**
 * 分页查询标签列表
 */
export const getTagListApi = (params: TagListQuery) => {
  return http.request<ApiResponse<PageResult<TagInfo>>>(
    "get",
    "/api/tags/list",
    { params }
  );
};

/**
 * 获取标签详情
 */
export const getTagDetailApi = (tagId: number) => {
  return http.request<ApiResponse<TagInfo>>("get", `/api/tags/${tagId}`);
};

/**
 * 创建标签
 */
export const createTagApi = (data: CreateTagRequest) => {
  return http.request<ApiResponse>("post", "/api/tags", { data });
};

/**
 * 更新标签
 */
export const updateTagApi = (
  tagId: number,
  data: Omit<UpdateTagRequest, "id">
) => {
  return http.request<ApiResponse>("put", `/api/tags/${tagId}`, { data });
};

/**
 * 删除标签
 */
export const deleteTagApi = (tagId: number) => {
  return http.request<ApiResponse>("delete", `/api/tags/${tagId}`);
};

/**
 * 批量操作标签
 */
export const batchOperateTagsApi = (params: BatchOperationParams) => {
  return http.request<ApiResponse>("post", "/api/tags/batch", { data: params });
};

// ==================== 标签查询接口 ====================

/**
 * 获取启用的标签列表
 */
export const getEnabledTagsApi = () => {
  return http.request<ApiResponse<SimpleTagInfo[]>>("get", "/api/tags/enabled");
};

/**
 * 搜索标签（自动完成）
 */
export const searchTagsApi = (keyword: string, limit: number = 10) => {
  return http.request<ApiResponse<SimpleTagInfo[]>>("get", "/api/tags/search", {
    params: { keyword, limit }
  });
};

/**
 * 获取热门标签
 */
export const getHotTagsApi = (limit: number = 20) => {
  return http.request<ApiResponse<SimpleTagInfo[]>>("get", "/api/tags/hot", {
    params: { limit }
  });
};

/**
 * 获取所有标签（无分页）
 * 文档：/api/tags/all-tags
 */
export const getAllTagsApi = () => {
  return http.request<ApiResponse<SimpleTagInfo[]>>(
    "get",
    "/api/tags/all-tags"
  );
};

/**
 * 根据标签查询文章
 */
export const getArticlesByTagApi = (tagId: number) => {
  return http.request<ApiResponse<number[]>>(
    "get",
    `/api/tags/${tagId}/articles`
  );
};

// ==================== 标签统计接口 ====================

/**
 * 获取标签统计信息
 */
export const getTagStatisticsApi = () => {
  return http.request<ApiResponse<TagStatistics>>(
    "get",
    "/api/tags/statistics"
  );
};

/**
 * 检查标签名称是否存在
 */
export const checkTagNameApi = (name: string, excludeId?: number) => {
  const params: any = { name };
  if (excludeId) {
    params.excludeId = excludeId;
  }
  return http.request<ApiResponse<boolean>>("get", "/api/tags/check-name", {
    params
  });
};

// ==================== 工具函数 ====================

/**
 * 格式化标签颜色
 */
export const formatTagColor = (color: string): string => {
  if (!color) return "#1890ff";
  return color.startsWith("#") ? color : `#${color}`;
};

/**
 * 获取使用频率等级文本
 */
export const getUsageLevelText = (level: number): string => {
  const levelMap: Record<number, string> = {
    0: "未使用",
    1: "低频",
    2: "中频",
    3: "高频"
  };
  return levelMap[level] || "未知";
};

/**
 * 获取标签状态文本
 */
export const getTagStatusText = (status: number): string => {
  return status === 1 ? "启用" : "禁用";
};

/**
 * 格式化标签使用次数
 */
export const formatUseCount = (count: number): string => {
  if (count === 0) return "未使用";
  if (count < 1000) return count.toString();
  if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
  return `${(count / 10000).toFixed(1)}w`;
};
